It is relatively common for a single processing node of a network to run simultaneously multiple stacks that handle different protocols. For example, a node might contain a TCP/IP stack for communications via the Internet or a corporate intranet, and at the same time run another stack such as perhaps a SNA (System Communications Architecture) stack for communications with IBM mainframes or IBM AS/400 nodes running IBM's APPN (Advanced-Peer-to-Peer) architecture. Naturally, if multiple dissimilar stacks are executing in a single node, then occasions arise in which packets must be passed between the dissimilar stacks in the ordinary course of events. Suppose, for example, that an application running under IBM's Advance-Peer-to-Peer Architecture (APPN) needs to communicate with another APPN application in a different node, but the only way of communicating between the nodes is the ubiquituous internet that uses the TCP/IP protocols. In such a case, it is desirable to communicate between an APPN stack and a TCP/IP stack in the same node so that the internet protocols can be used between the end nodes. In the known prior art, communication between different types of stacks in the same node is accomplished in one of two ways. In some cases, actual physical links and routers with protocol conversion can be used to route from one stack of a node back to a different stack of the same node. In the case of IBM's APPN, an APPN stack can communicate with a TCP/IP stack in the same node via a sockets software interface between the two stacks.
FIG. 1 shows an example of the APPN-TCP/IP prior art arrangement. FIG. 1 shows a node 100 that contains an APPN stack A and a TCP/IP stack B. Input/output services function 102 is shown that contains adapters, such as 104 and 110, that allow the node to communicate with incoming and outgoing links. The I/O services 102 also contains a sockets interface 106 and a SNA exit 108 that together connect the bottom Data Link Control (DLC) layer of the APPN stack to the top TCP layer of the TCP/IP stack. The sockets interface 106 is an API available to Applications within this node, allowing Applications to connect to the TCP/IP stack, thus allowing the Application to communicate with remote applications with similar purpose (e.g. File Transfer Program). The SNA exit 108 consists of software routines (programs) that are driven as part of the Sockets Interface (API), allowing the TCP/IP stack to pass unsolicited information to the Application (Socket), such as passing data (packets) to the application. In this arrangement, when an APPN application serviced by the APPN stack A wishes to communicate with an external application using the TCP/IP protocols, the data packets must pass through the sockets interface 106 and the SNA exit 108 to the top TCP layer of the TCP/IP stack B. The various layers of the TCP/IP stack must then process the packets as the packets move down the stack on the way to an external link via adapter 110. Obviously, this is very expensive in terms of processing cycles. It would be much more efficient if a way can be devised to enter the outbound stack, i.e., the TCP/IP B stack in this example, at the bottom Interface (IF) layer. This way, a packet would only be processed by the IF layer before being routed out to an external link, rather than being processed through all layers of the TCP/IP stack. Thus, while the prior art APPN-TCP/IP arrangement of using a sockets interface to enter the top layer of the TCP/IP stack is satisfactory from a functional point of view, it is apparent that it requires resources that are inefficient and expensive in terms of the data processing required.